package com.example.innospace.demos.web.service.Impl;

import com.example.innospace.demos.json.JsonConverter;
import com.example.innospace.demos.pojo.Request.ApprovalRequest;
import com.example.innospace.demos.pojo.Request.RequestType;
import com.example.innospace.demos.pojo.param.*;
import com.example.innospace.demos.web.reposity.ApprovalRequestRepository;
import com.example.innospace.demos.web.service.ApprovalRequestService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Date;
import java.util.List;

// 实现 ApprovalRequestService 接口，提供具体的业务逻辑
@Service
public  class ApprovalRequestServiceImpl implements ApprovalRequestService {


    // 注入 ApprovalRequestRepository 用于数据库操作
    @Autowired
    private ApprovalRequestRepository approvalRequestRepository;

    @Autowired
    private JsonConverter jsonConverter;


    @Autowired
    private ProjectServiceImpl projectService;

    /**
     * 添加申请请求
     */
    @Override
    public ApprovalRequest submitRequest(ApprovalRequest request) {
        // 设置申请的创建时间和初始状态为 PENDING
        request.setCreateTime(new Date());
        request.setStatus("PENDING");
        // 保存申请到数据库
        return approvalRequestRepository.save(request);
    }

    /**
     * 查询当前未处理的申请
     * @return
     */
    @Override
    public List<ApprovalRequest> getPendingRequests() {
        // 根据审批人 ID 和状态为 PENDING 查询待审批的申请列表
        return approvalRequestRepository.findByStatus( "PENDING");
    }

    /**
     * 对申请进行处理
     * @param requestId
     * @param status
     * @return 如果请求被同意，那么处理结果是按申请中存储的内容来更新的，但是如果被拒接则按被拒接的来修改
     */
    @Override
    public ApprovalRequest approveRequest(String status, Long requestId) {
        // 根据申请 ID 从数据库中查找申请
        ApprovalRequest request = approvalRequestRepository.findById(requestId).orElse(null);
        if (request != null) {
            // 更新申请的状态和更新时间
            request.setStatus(status);
            request.setUpdateTime(new Date());

            // 根据不同的申请类型执行不同的操作
            if ("APPROVED".equals(status)) {
                RequestType requestType = RequestType.valueOf(String.valueOf(request.getRequestType()));
                switch (requestType) {
                    case PROJECT_MODIFICATION:
                        // 处理项目修改申请通过后的逻辑
                        handleProjectModificationApproval(request);
                        break;
                    case MEMBER_CHANGE:
                        // 处理成员变更申请通过后的逻辑
                        handleMemberChangeApproval(request);
                        break;
                    case FIRST_TEACHER_CHANGE:
                        // 处理第一指导老师变更申请通过后的逻辑
                        handleFirstTeacherChangeApproval(request);
                        break;
                    case SECOND_TEACHER_CHANGE:
                        // 处理第二指导老师变更申请通过后的逻辑
                        handleSecondTeacherChangeApproval(request);
                        break;
                    case COLLEGE_REVIEW:
                        // 处理学院审核申请通过后的逻辑
                        handleCollegeReviewApproval(request);
                        break;
                    case SCHOOL_REVIEW:
                        // 处理学校审核申请通过后的逻辑
                        handleSchoolReviewApproval(request);
                        break;
                    case DELETE_PROJECT:
                        // 处理删除项目申请通过后的逻辑
                        handleDeleteProjectApproval(request);
                        break;
                    case MODIFY_PROJECT_LEVEL:
                        // 处理修改项目级别申请通过后的逻辑
                        handleModifyProjectLevelApproval(request);
                        break;
                    case MID_TERM_REVIEW:
                        // 处理项目中期审核申请通过后的逻辑
                        handleMidTermReviewApproval(request);
                        break;
                    case MID_TERM_EXTENSION:
                        // 处理中期延期申请通过后的逻辑
                        handleMidTermExtensionApproval(request);
                        break;
                    default:
                        // 可以添加默认处理逻辑
                        break;
                }
            }

            // 保存更新后的申请到数据库
            return approvalRequestRepository.save(request);
        }
        return null;
    }

    // 处理项目修改申请通过后的逻辑
    private void handleProjectModificationApproval(ApprovalRequest request) {
        // 这里添加具体的项目修改申请通过后的业务逻辑
// 这里添加具体的项目修改申请通过后的业务逻辑
        System.out.println("项目修改申请已通过，执行相应操作");
        // 假设 ApprovalRequest 中有一个字段存储了 JSON 数据
        String json = request.getJsonData();
        try {
            // 将 JSON 字符串转换为 ProjectModificationParams 对象
            ProjectModificationParams params = jsonConverter.fromJson(json, ProjectModificationParams.class);
            // 调用 updateProject 方法
            boolean result = projectService.updateProject(params.getProject(), params.getFiles());
            if (result) {
                System.out.println("项目修改操作成功");
            } else {
                System.out.println("项目修改操作失败");
            }
        } catch (Exception e) {
            System.err.println("解析 JSON 或执行项目修改操作时出错: " + e.getMessage());
        }
        System.out.println("项目修改申请已通过，执行相应操作");
    }

    // 处理成员变更申请通过后的逻辑
    private void handleMemberChangeApproval(ApprovalRequest request) {
        // 这里添加具体的成员变更申请通过后的业务逻辑
        System.out.println("成员变更申请已通过，执行相应操作");
        // 假设 ApprovalRequest 中有一个字段存储了 JSON 数据
        String json = request.getJsonData();
        try {
            // 将 JSON 字符串转换为 MemberChangeParams 对象
            MemberChangeParams params = jsonConverter.fromJson(json, MemberChangeParams.class);
            // 调用 updateStudents 方法
            boolean result =projectService.updateStudents(params.getStudentIds(), params.getStudentId(), params.getId());
            if (result) {
                System.out.println("成员变更操作成功");
            } else {
                System.out.println("成员变更操作失败，部分新增成员已有项目");
            }
        } catch (RuntimeException e) {
            System.err.println("解析 JSON 或执行成员变更操作时出错: " + e.getMessage());
        }
        System.out.println("成员变更申请已通过，执行相应操作");
    }

    // 这里添加具体的第一指导老师变更申请通过后的业务逻辑
    private void handleFirstTeacherChangeApproval(ApprovalRequest request) {
        System.out.println("第一指导老师变更申请已通过，执行相应操作");
        // 假设 ApprovalRequest 中有一个字段存储了 JSON 数据
        String json = request.getJsonData();
        try {
            // 将 JSON 字符串转换为 FirstTeacherChangeParams 对象
            FirstTeacherChangeParams params = jsonConverter.fromJson(json, FirstTeacherChangeParams.class);
            // 调用 updateTeacherFirst 方法
            projectService.updateTeacherFirst(params.getTeacherId(), params.getUpdaterId(), params.getId());
            System.out.println("第一指导老师变更操作成功");
        } catch (Exception e) {
            System.err.println("解析 JSON 或执行第一指导老师变更操作时出错: " + e.getMessage());
        }
        System.out.println("第一指导老师变更申请已通过，执行相应操作");
    }

    // 这里添加具体的第二指导老师变更申请通过后的业务逻辑
    private void handleSecondTeacherChangeApproval(ApprovalRequest request) {
        System.out.println("第二指导老师变更申请已通过，执行相应操作");
        // 假设 ApprovalRequest 中有一个字段存储了 JSON 数据
        String json = request.getJsonData();
        try {
            // 将 JSON 字符串转换为 SecondTeacherChangeParams 对象
            SecondTeacherChangeParams params = jsonConverter.fromJson(json, SecondTeacherChangeParams.class);
            // 调用 updateTeacherSecond 方法
            projectService.updateTeacherSecond(params.getTeacherId(), params.getUpdaterId(), params.getId());
            System.out.println("第二指导老师变更操作成功");
        } catch (Exception e) {
            System.err.println("解析 JSON 或执行第二指导老师变更操作时出错: " + e.getMessage());
        }
        System.out.println("第二指导老师变更申请已通过，执行相应操作");
    }


    // 这里添加具体的学院审核申请通过后的业务逻辑
    private void handleCollegeReviewApproval(ApprovalRequest request) {
        System.out.println("学院审核申请已通过，执行相应操作");
        // 假设 ApprovalRequest 中有一个字段存储了 JSON 数据
        String json = request.getJsonData();
        try {
            // 将 JSON 字符串转换为 CollegeReviewParams 对象
            CollegeReviewParams params = jsonConverter.fromJson(json, CollegeReviewParams.class);
            // 调用 updateCollegeApprovalStatus 方法
            projectService.updateCollegeApprovalStatus(params.getProjectId(), params.isPassed());
            System.out.println("学院审核状态更新成功");
        } catch (Exception e) {
            System.err.println("解析 JSON 或执行学院审核状态更新操作时出错: " + e.getMessage());
        }
        System.out.println("学院审核申请已通过，执行相应操作");
    }

    // 这里添加具体的学校审核申请通过后的业务逻辑
    private void handleSchoolReviewApproval(ApprovalRequest request) {
        System.out.println("学校审核申请已通过，执行相应操作");
        // 假设 ApprovalRequest 中有一个字段存储了 JSON 数据
        String json = request.getJsonData();
        try {
            // 将 JSON 字符串转换为 SchoolReviewParams 对象
            SchoolReviewParams params = jsonConverter.fromJson(json, SchoolReviewParams.class);
            // 调用 updateSchoolApprovalStatus 方法
            projectService.updateSchoolApprovalStatus(params.getProjectId(), params.isPassed());
            System.out.println("学校审核状态更新成功");
        } catch (Exception e) {
            System.err.println("解析 JSON 或执行学校审核状态更新操作时出错: " + e.getMessage());
        }
        System.out.println("学校审核申请已通过，执行相应操作");
    }


    // 这里添加具体的删除项目申请通过后的业务逻辑
    private void handleDeleteProjectApproval(ApprovalRequest request) {
        System.out.println("删除项目申请已通过，执行相应操作");
        // 假设 ApprovalRequest 中有一个字段存储了 JSON 数据
        String json = request.getJsonData();
        try {
            // 将 JSON 字符串转换为 DeleteProjectParams 对象
            DeleteProjectParams params = jsonConverter.fromJson(json, DeleteProjectParams.class);
            // 调用 deleteByProjectId 方法
            projectService.deleteByProjectId(params.getProjectId());
            System.out.println("项目删除成功");
        } catch (Exception e) {
            System.err.println("解析 JSON 或执行删除项目操作时出错: " + e.getMessage());
        }
        System.out.println("删除项目申请已通过，执行相应操作");

    }

    // 这里添加具体的修改项目级别申请通过后的业务逻辑
    private void handleModifyProjectLevelApproval(ApprovalRequest request) {
        System.out.println("修改项目级别申请已通过，执行相应操作");
        // 假设 ApprovalRequest 中有一个字段存储了 JSON 数据
        String json = request.getJsonData();
        try {
            // 将 JSON 字符串转换为 ModifyProjectLevelParams 对象
            ModifyProjectLevelParams params = jsonConverter.fromJson(json, ModifyProjectLevelParams.class);
            // 调用 updateLevel 方法
            projectService.updateLevel(params.getId(), params.getLevel());
            System.out.println("项目级别修改成功");
        } catch (Exception e) {
            System.err.println("解析 JSON 或执行修改项目级别操作时出错: " + e.getMessage());
        }
        System.out.println("修改项目级别申请已通过，执行相应操作");

    }

    // 这里添加具体的项目中期审核申请通过后的业务逻辑
    private void handleMidTermReviewApproval(ApprovalRequest request) {
        System.out.println("项目中期审核申请已通过，执行相应操作");

    }

    // 处理中期延期申请通过后的逻辑
    private void handleMidTermExtensionApproval(ApprovalRequest request) {
        // 假设从 jsonData 中能解析出相关信息（这里只是示例，实际可能需要更复杂的解析逻辑）
        String jsonData = request.getJsonData();
        // 这里假设 jsonData 中有一个字段记录了 isProjectExtended 的值，以下是模拟获取
        try{
            MidTermExtensionParams params = jsonConverter.fromJson(jsonData,MidTermExtensionParams.class);
            if(params.isProjectExtended()==true)
            {
                projectService.submitMidtermExtensionRequest(params.isProjectExtended(),params.getProjectId());
                System.out.println("执行申请中期延期通过后的具体业务逻辑");
            }
            else
            {
                System.out.println("执行取消中期延期通过后的具体业务逻辑");
                projectService.submitMidtermExtensionRequest(params.isProjectExtended(), params.getProjectId());
            }
        }catch (Exception e) {
            System.err.println("解析 JSON 或执行修改项目级别操作时出错: " + e.getMessage());
        }
    }
}